﻿using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using Assist;
using Autodesk.Revit.DB;
using Autodesk.Revit.DB.ExtensibleStorage;
using Autodesk.Revit.DB.Plumbing;
using Autodesk.Revit.UI;
using YArchitech.HVAC;
using YArchitech.LIB;
using YArchitech.Revit;
using YArchitech.Revit.RevitExtension;
using Transfer.Utils;

namespace YArchitech.Plumbing
{
	public class MarkRiserPipeUtility
	{
		public static double YOffSetHori
		{
			get
			{
				return 180.0 + RevitVersionFuncs.AddOffsetInVersion(6);
			}
		}

		public static List<Line> DrawSinglePipeMarkLines(XYZ pipePoint, XYZ location, double angle, bool isCustomAngle, double distance, double textLength, ref XYZ textLocation, ref XYZ subLineDir, Autodesk.Revit.DB.Document doc, bool isleft = false)
		{
			List<Line> list = new List<Line>();
			try
			{
				double num = angle * Math.PI / 180.0;
				XYZ xyz = new XYZ(location.X, pipePoint.Y, pipePoint.Z);
				XYZ xyz2 = new XYZ(pipePoint.X, location.Y, pipePoint.Z);
				XYZ xyz3 = location - xyz2;
				XYZ xyz4 = location - xyz;
				if (xyz3.IsAlmostEqualTo(new XYZ(0.0, 0.0, 0.0)))
				{
					if (isleft)
					{
						xyz3 = new XYZ(-1.0, 0.0, 0.0);
					}
					else
					{
						xyz3 = new XYZ(1.0, 0.0, 0.0);
					}
				}
				if (isCustomAngle)
				{
					num = angle * Math.PI / 180.0;
				}
				else
				{
					num = Math.Asin(Math.Abs(location.Y - pipePoint.Y) / location.DistanceTo(pipePoint));
				}
				XYZ xyz5;
				if (num == 0.0)
				{
					xyz5 = pipePoint.Add(xyz3.Normalize() * Math.Abs(location.X - pipePoint.X));
				}
				else
				{
					double num2 = AssistFunc.mmToFeet(distance) * Math.Tan(Math.PI*.5 - num);
					xyz5 = pipePoint.Add(xyz3.Normalize() * num2).Add(xyz4.Normalize() * AssistFunc.mmToFeet(distance));
				}
				XYZ xyz6 = xyz5.Add(xyz3.Normalize() * AssistFunc.mmToFeet(textLength));
				list.Add(YJKLineEx.YJKGetBound(pipePoint, xyz5));
				list.Add(YJKLineEx.YJKGetBound(xyz5, xyz6));
				textLocation = xyz5;
				subLineDir = xyz6 - xyz5;
			}
			catch (Exception ex)
			{
				ex.ToString();
			}
			return list;
		}

		public static List<Line> DrawMultiPipesMarkLines(List<RiserPipeAndCenter> sortedPipePoints, XYZ location, XYZ markVector, double textLength, ref List<RiserPipeAndCenter> textLocationList, ref XYZ subLineDir, ref XYZ intersection, double height = 0.0)
		{
			double num = MarkRiserPipeUtility.TextHeight;
			if (height != 0.0)
			{
				num = height;
			}
			List<Line> list = new List<Line>();
			textLocationList = new List<RiserPipeAndCenter>();
			try
			{
				int count = sortedPipePoints.Count;
				if (count > 0)
				{
					XYZ location2 = sortedPipePoints[0].Location;
					XYZ end = location2.Add(markVector);
					YJKLine line = null;
					XYZ direction = null;
					XYZ xyz = null;
					if (Geometry.GreaterThan(markVector.Y, 0.0))
					{
						direction = new XYZ(1.0, 0.0, 0.0);
						xyz = new XYZ(0.0, 1.0, 0.0);
						line = new YJKLine(location2, end);
					}
					else if (Geometry.LessThan(markVector.Y, 0.0))
					{
						direction = new XYZ(1.0, 0.0, 0.0);
						xyz = new XYZ(0.0, -1.0, 0.0);
						line = new YJKLine(location2, end);
					}
					else if (Geometry.IsEqual(markVector.Y, 0.0))
					{
						direction = new XYZ(0.0, 1.0, 0.0);
						if (Geometry.GreaterThan(sortedPipePoints[0].Location.Y, location.Y))
						{
							subLineDir = new XYZ(0.0, -1.0, 0.0);
						}
						else if (Geometry.LessThan(sortedPipePoints[0].Location.Y, location.Y))
						{
							subLineDir = new XYZ(0.0, 1.0, 0.0);
						}
						line = new YJKLine(location2, end);
					}
					intersection = MarkRiserPipeUtility.GetIntersection(line, location, direction);
					if (Geometry.IsEqual(markVector.Y, 0.0))
					{
						if (Geometry.GreaterThan(markVector.X, 0.0))
						{
							xyz = new XYZ(1.0, 0.0, 0.0);
						}
						else if (Geometry.LessThan(markVector.X, 0.0))
						{
							xyz = new XYZ(-1.0, 0.0, 0.0);
						}
						intersection = new XYZ(intersection.X, intersection.Y, intersection.Z);
						RiserPipeAndCenter item = new RiserPipeAndCenter(sortedPipePoints[0].RiserPipe, intersection);
						textLocationList.Add(item);
						XYZ xyz2 = location2;
						XYZ endPoint = intersection;
						list.Add(YJKLineEx.YJKGetBound(xyz2, endPoint));
						for (int i = 1; i < count; i++)
						{
							XYZ start = intersection.Add(xyz.Normalize() * AssistFunc.mmToFeet((double)i * num));
							XYZ intersection2 = MarkRiserPipeUtility.GetIntersection(line, start, direction);
							item = new RiserPipeAndCenter(sortedPipePoints[i].RiserPipe, intersection2);
							textLocationList.Add(item);
						}
						int num2 = 0;
						using (List<RiserPipeAndCenter>.Enumerator enumerator = textLocationList.GetEnumerator())
						{
							while (enumerator.MoveNext())
							{
								RiserPipeAndCenter riserPipeAndCenter = enumerator.Current;
								if (num2 > 0 && !xyz2.IsAlmostEqualTo(riserPipeAndCenter.Location))
								{
									list.Add(YJKLineEx.YJKGetBound(xyz2, riserPipeAndCenter.Location));
								}
								xyz2 = riserPipeAndCenter.Location;
								endPoint = xyz2.Add(subLineDir.Normalize() * AssistFunc.mmToFeet(textLength));
								list.Add(YJKLineEx.YJKGetBound(xyz2, endPoint));
								num2++;
							}
							goto IL_51E;
						}
					}
					RiserPipeAndCenter item2 = new RiserPipeAndCenter(sortedPipePoints[0].RiserPipe, intersection);
					textLocationList.Add(item2);
					subLineDir = location - intersection;
					XYZ xyz3 = location2;
					XYZ endPoint2 = intersection;
					list.Add(YJKLineEx.YJKGetBound(xyz3, endPoint2));
					for (int j = 1; j < count; j++)
					{
						XYZ start2 = location.Add(xyz.Normalize() * AssistFunc.mmToFeet((double)j * num));
						XYZ xyz4 = MarkRiserPipeUtility.GetIntersection(line, start2, direction);
						xyz4 = new XYZ(intersection.X, xyz4.Y, xyz4.Z);
						item2 = new RiserPipeAndCenter(sortedPipePoints[j].RiserPipe, xyz4);
						textLocationList.Add(item2);
					}
					int num3 = 0;
					foreach (RiserPipeAndCenter riserPipeAndCenter2 in textLocationList)
					{
						if (num3 > 0 && !xyz3.IsAlmostEqualTo(riserPipeAndCenter2.Location))
						{
							list.Add(YJKLineEx.YJKGetBound(xyz3, riserPipeAndCenter2.Location));
						}
						xyz3 = riserPipeAndCenter2.Location;
						endPoint2 = xyz3.Add(subLineDir.Normalize() * AssistFunc.mmToFeet(textLength));
						list.Add(YJKLineEx.YJKGetBound(xyz3, endPoint2));
						num3++;
					}
				}
				IL_51E:;
			}
			catch (Exception ex)
			{
				ex.ToString();
				throw ex;
			}
			return list;
		}

		protected static XYZ GetIntersection(YJKLine line, XYZ start, XYZ direction)
		{
			Line otherLine = YJKLineEx.YJKGetBound(start, start.Add(direction));
			return line.IntersectionPoint(otherLine, false);
		}

		public static double GetTextLength(bool withArea, bool withFloor)
		{
			double result = MarkRiserPipeUtility.TextLength;
			if (withArea && withFloor)
			{
				result = 1400.0;
			}
			else if (!withArea && withFloor)
			{
				result = 1100.0;
			}
			else if (withArea && !withFloor)
			{
				result = 1100.0;
			}
			else if (!withArea && !withFloor)
			{
				result = 800.0;
			}
			return result;
		}

		public static double GetTextXOffsetHori(bool withArea, bool withFloor)
		{
			double result = MarkRiserPipeUtility.XOffsetHori;
			if (withArea && withFloor)
			{
				result = 710.0;
			}
			else if (!withArea && withFloor)
			{
				result = 550.0;
			}
			else if (withArea && !withFloor)
			{
				result = 550.0;
			}
			else if (!withArea && !withFloor)
			{
				result = 400.0;
			}
			return result;
		}

		public static double GetTextXOffsetVert(bool withArea, bool withFloor)
		{
			return MarkRiserPipeUtility.XOffsetVert;
		}

		public static double GetTextYOffsetHori(bool withArea, bool withFloor)
		{
			return MarkRiserPipeUtility.YOffSetHori;
		}

		public static double GetTextYOffsetVert(bool withArea, bool withFloor)
		{
			double result = MarkRiserPipeUtility.YOffSetVert;
			if (withArea && withFloor)
			{
				result = 700.0;
			}
			else if (!withArea && withFloor)
			{
				result = 540.0;
			}
			else if (withArea && !withFloor)
			{
				result = 540.0;
			}
			else if (!withArea && !withFloor)
			{
				result = 400.0;
			}
			return result;
		}

		public static List<RiserPipeAndCenter> SortPoints(List<RiserPipeAndCenter> pipeAndCenterList, XYZ currentPoint)
		{
			List<RiserPipeAndCenter> result = null;
			if (pipeAndCenterList.Count > 0)
			{
				double num = double.MinValue;
				XYZ startPt = null;
				foreach (RiserPipeAndCenter riserPipeAndCenter in pipeAndCenterList)
				{
					if (currentPoint.DistanceTo(riserPipeAndCenter.Location) > num)
					{
						startPt = riserPipeAndCenter.Location;
						num = currentPoint.DistanceTo(riserPipeAndCenter.Location);
					}
				}
				result = (from a in pipeAndCenterList
				orderby a.Location.DistanceTo(startPt)
				select a).ToList<RiserPipeAndCenter>();
			}
			return result;
		}

		public static Schema CreatePipelInfoSchema()
		{
			Schema schema = Schema.Lookup(MarkRiserPipeUtility.RiserPipeMarkGUID);
			if (schema != null)
			{
				return schema;
			}
			SchemaBuilder schemaBuilder = new SchemaBuilder(MarkRiserPipeUtility.RiserPipeMarkGUID);
			schemaBuilder.SetSchemaName("RiserPipeMark");
			schemaBuilder.AddSimpleField("RiserPipeMarkGroups", typeof(string));
			schemaBuilder.AddSimpleField("ReservedField", typeof(string));
			schemaBuilder.AddSimpleField("TagLayPoints", typeof(string));
			return schemaBuilder.Finish();
		}

		public static void WriteDetailGroupsInfo(Element elem, string detailGoups)
		{
			Schema schema = MarkRiserPipeUtility.CreatePipelInfoSchema();
			Entity entity = elem.GetEntity(schema);
			if (entity == null || entity.Schema == null)
			{
				entity = new Entity(schema);
			}
			Field field = schema.GetField("RiserPipeMarkGroups");
			if (field != null && entity != null)
			{
				entity.Set<string>(field, detailGoups);
				elem.SetEntity(entity);
			}
		}

		public static void WritePipeTagInfo(Element elem, IndependentTag tag)
		{
			string text = MarkRiserPipeUtility.ReadTagInfo(elem);
			if (text != null && !string.IsNullOrEmpty(text))
			{
				text += "*";
			}
			text += MarkRiserPipeUtility.GetTagMarkInfo(tag);
			MarkRiserPipeUtility.WritePipeTagInfo(elem, text);
		}

		public static List<TagMarkInformation> GetMarkTagInfo(Element elem)
		{
			List<TagMarkInformation> list = new List<TagMarkInformation>();
			string text = MarkRiserPipeUtility.ReadTagInfo(elem);
			if (string.IsNullOrEmpty(text))
			{
				return null;
			}
			string[] array = text.Split(new char[]
			{
				'*'
			});
			if (array == null || array.Count<string>() < 1)
			{
				return null;
			}
			string[] array2 = array;
			for (int i = 0; i < array2.Length; i++)
			{
				TagMarkInformation tagMarkInformation = MarkRiserPipeUtility.AnalysisMarkInfo(array2[i]);
				if (tagMarkInformation != null)
				{
					list.Add(tagMarkInformation);
				}
			}
			return list;
		}

		public static TagMarkInformation AnalysisMarkInfo(string strInfo)
		{
			TagMarkInformation result = null;
			if (string.IsNullOrEmpty(strInfo))
			{
				return result;
			}
			string[] array = strInfo.Split(new char[]
			{
				','
			});
			if (array == null || array.Count<string>() != 4)
			{
				return result;
			}
			int id = Convert.ToInt32(array[0]);
			double num = Convert.ToDouble(array[1]);
			double num2 = Convert.ToDouble(array[2]);
			double num3 = Convert.ToDouble(array[3]);
			XYZ point = new XYZ(num, num2, num3);
			return new TagMarkInformation(id, point);
		}

		public static void WritePipeTagInfo(Element elem, string tagInfo)
		{
			Schema schema = MarkRiserPipeUtility.CreatePipelInfoSchema();
			Entity entity = elem.GetEntity(schema);
			if (entity == null || entity.Schema == null)
			{
				entity = new Entity(schema);
			}
			Field field = schema.GetField("TagLayPoints");
			if (field != null && entity != null)
			{
				entity.Set<string>(field, tagInfo);
				elem.SetEntity(entity);
			}
		}

		private static string GetTagMarkInfo(IndependentTag tag)
		{
			XYZ tagHeadPosition = tag.TagHeadPosition;
			return string.Concat(new object[]
			{
				tag.Id.IntegerValue,
				",",
				tagHeadPosition.X,
				",",
				tagHeadPosition.Y,
				",",
				tagHeadPosition.Z
			});
		}

		public static string ReadDetailGroupsInfo(Element elem)
		{
			string result = string.Empty;
			Schema schema = MarkRiserPipeUtility.CreatePipelInfoSchema();
			Entity entity = elem.GetEntity(schema);
			Field field = schema.GetField("RiserPipeMarkGroups");
			if (field != null && entity != null && entity.Schema != null)
			{
				result = entity.Get<string>(field);
			}
			return result;
		}

		public static string ReadTagInfo(Element elem)
		{
			string result = string.Empty;
			Schema schema = MarkRiserPipeUtility.CreatePipelInfoSchema();
			Entity entity = elem.GetEntity(schema);
			Field field = schema.GetField("TagLayPoints");
			if (field != null && entity != null && entity.Schema != null)
			{
				result = entity.Get<string>(field);
			}
			return result;
		}

		public static Autodesk.Revit.DB.Group WriteMarkGroupsToRiserPipe(Autodesk.Revit.DB.Document doc, List<RiserPipeAndCenter> pipes, DetailCurveArray curveList)
		{
			Autodesk.Revit.DB.Group group = null;
			ElementSet elementSet = new ElementSet();
			foreach (object obj in curveList)
			{
				DetailCurve detailCurve = (DetailCurve)obj;
				elementSet.Insert(detailCurve);
			}
			if (elementSet.Size > 0)
			{
				group = doc.CreatYJKGroup(elementSet);
				foreach (RiserPipeAndCenter riserPipeAndCenter in pipes)
				{
					string text = MarkRiserPipeUtility.ReadDetailGroupsInfo(riserPipeAndCenter.RiserPipe);
					if (text != null)
					{
						if (text != string.Empty)
						{
							text += "*";
						}
						text += group.Id.ToString();
						MarkRiserPipeUtility.WriteDetailGroupsInfo(riserPipeAndCenter.RiserPipe, text);
					}
				}
			}
			return group;
		}

		public static bool MarkSinglePipeText(Autodesk.Revit.DB.Document doc, Autodesk.Revit.DB.View view, Pipe pipe, XYZ textLocation, XYZ subVector, double textLength, bool withArea, bool withFloor, Autodesk.Revit.DB.Group group, double height, ref IndependentTag tag)
		{
			bool result = false;
			XYZ xyz = new XYZ(0.0, 1.0, 0.0);
			XYZ xyz2 = new XYZ(1.0, 0.0, 0.0);
			MarkRiserPipeUtility.DeleteRiserPipeTag(pipe);
			FamilySymbol familySymbol = YJKRevitTools.GetFamilySymbol(doc, "HY_水管立管标记", BuiltInCategory.OST_PipeTags);
			bool flag;
			if (familySymbol == null)
			{
				string markFamilyPath = UnifiedModified.GetMarkFamilyPath(doc, "HY_水管立管标记");
				flag = doc.LoadFamily(markFamilyPath);
			}
			else
			{
				flag = true;
			}
			if (!flag)
			{
				familySymbol = YJKRevitTools.GetFamilySymbol(doc, "HY_水管立管标记", BuiltInCategory.OST_PipeTags);
				if (familySymbol != null)
				{
					flag = true;
				}
			}
			TagOrientation tagOrientation = 0;
			if (flag)
			{
				textLocation = textLocation.Add(xyz2 * AssistFunc.mmToFeet(textLength / 2.0)).Add(xyz * AssistFunc.mmToFeet(height));
				if (Geometry.LessThan(subVector.X, 0.0))
				{
					textLocation = textLocation.Add(subVector.Normalize() * AssistFunc.mmToFeet(textLength));
				}
				tag = RevitVersionFuncs.NewTag(doc, view, new Reference(pipe), false, 0, tagOrientation, textLocation);
				tag.ChangeTypeId(new ElementId(familySymbol.Id.IntegerValue));
				tag.HasLeader = false;
				tag.TagHeadPosition = textLocation;
				AssociationMarkInfo.WriteMarkInfoToElement(tag, YArchitech.HVAC.MarkType.RiserPipe);
				MarkRiserPipeUtility.WritePipeTagInfo(pipe, tag);
				MarkRiserPipeUtility.WriteTagsInfo(group, tag.Id.IntegerValue.ToString());
				result = true;
			}
			return result;
		}

		public static void DeleteRiserPipeTag(Pipe pipe)
		{
		}

		public static Schema CreateGroupInfoSchema()
		{
			Schema schema = Schema.Lookup(MarkRiserPipeUtility.GroupGUID);
			if (schema != null)
			{
				return schema;
			}
			SchemaBuilder schemaBuilder = new SchemaBuilder(MarkRiserPipeUtility.GroupGUID);
			schemaBuilder.SetSchemaName("DetailGroupExtension");
			schemaBuilder.AddSimpleField("ToggledTags", typeof(string));
			schemaBuilder.AddSimpleField("GroupReservedField", typeof(string));
			return schemaBuilder.Finish();
		}

		public static void WriteTagsInfo(Element elem, string tags)
		{
			Schema schema = MarkRiserPipeUtility.CreateGroupInfoSchema();
			Entity entity = elem.GetEntity(schema);
			if (entity == null || entity.Schema == null)
			{
				entity = new Entity(schema);
			}
			Field field = schema.GetField("ToggledTags");
			if (field != null && entity != null)
			{
				entity.Set<string>(field, tags);
				elem.SetEntity(entity);
			}
		}

		public static string ReadTagsInfo(Element elem)
		{
			string result = string.Empty;
			Schema schema = MarkRiserPipeUtility.CreateGroupInfoSchema();
			Entity entity = elem.GetEntity(schema);
			Field field = schema.GetField("ToggledTags");
			if (field != null && entity != null && entity.Schema != null)
			{
				result = entity.Get<string>(field);
			}
			return result;
		}

		public static List<ElementId> GetDetailGroupId(Element elem, bool bePipe = true)
		{
			List<ElementId> list = new List<ElementId>();
			string text = MarkRiserPipeUtility.ReadDetailGroupsInfo(elem);
			if (!bePipe)
			{
				text = MarkRiserPipeUtility.ReadTagsInfo(elem);
			}
			if (string.IsNullOrEmpty(text))
			{
				return null;
			}
			List<string> list2 = text.Split(new char[]
			{
				'*'
			}).ToList<string>();
			if (list2 == null || list2.Count < 1)
			{
				return null;
			}
			foreach (string value in list2)
			{
				ElementId item = new ElementId(Convert.ToInt32(value));
				list.Add(item);
			}
			return list;
		}

		public static XYZ GetPointOnLineInGroup(Autodesk.Revit.DB.Document doc, ElementId elemID)
		{
			XYZ result = null;
			Autodesk.Revit.DB.Group group = doc.GetElementById(elemID) as Autodesk.Revit.DB.Group;
			if (group == null)
			{
				return result;
			}
			DetailLine detailLine = doc.GetElementById(group.GetMemberIds().First<ElementId>()) as DetailLine;
			if (detailLine == null)
			{
				return result;
			}
			return (detailLine.Location as LocationCurve).Curve.GetEndPoint(0);
		}

		public static List<PipingSystemType> GetAllPipeSystemType(Autodesk.Revit.DB.Document doc)
		{
			List<PipingSystemType> list = new List<PipingSystemType>();
			foreach (Element element in new FilteredElementCollector(doc).OfClass(typeof(PipingSystemType)).ToElements())
			{
				PipingSystemType item = element as PipingSystemType;
				list.Add(item);
			}
			return list;
		}

		public static bool SetRiserPipeParameters(UIApplication uiApp, Pipe pipe, string areaAndFloor, string number, bool isCustomNumber, bool existNum = false)
		{
			bool result = false;
			try
			{
				string text = Path.Combine(Product.DataLocation, "HYShared Parameters.txt");
				DefinitionFile defineFile = YJKRevitTools.OpenShareParamFile(uiApp, text);
				CategorySet bdcategorySet = YJKRevitTools.GetBDCategorySet(uiApp, BuiltInCategory.OST_PipingSystem);
				TypeBinding elemBinding = YJKRevitTools.CreatElemBinding(uiApp, bdcategorySet, "type") as TypeBinding;
				YJKRevitTools.SetShareParameter(uiApp, defineFile, "管道参数", new List<string>
				{
					"立管最大编号"
				}, elemBinding, (BuiltInParameterGroup)(-5000123));
				YJKRevitTools.SetInstanceParameter(uiApp, text, "管道参数", "区号楼号", BuiltInCategory.OST_PipeCurves, true);
				YJKRevitTools.SetInstanceParameter(uiApp, text, "管道参数", "立管编号", BuiltInCategory.OST_PipeCurves, true);
				List<PipingSystemType> allPipeSystemType = MarkRiserPipeUtility.GetAllPipeSystemType(uiApp.ActiveUIDocument.Document);
				if (allPipeSystemType != null && allPipeSystemType.Count > 0 && pipe != null)
				{
					Parameter parameter = pipe.get_Parameter(BuiltInParameter.RBS_PIPING_SYSTEM_TYPE_PARAM);
					if (parameter != null)
					{
						foreach (PipingSystemType pipingSystemType in allPipeSystemType)
						{
							if (parameter.AsElementId() == pipingSystemType.Id)
							{
								if (!existNum)
								{
									int num = 0;
									Parameter parameter2 = pipingSystemType.GetParameter("立管最大编号");
									if (parameter2 != null)
									{
										num = Convert.ToInt32(parameter2.AsString());
									}
									Parameter parameter3 = pipe.GetParameter("立管编号");
									if (parameter3 != null)
									{
										if (isCustomNumber)
										{
											parameter3.Set(number);
											try
											{
												if (Convert.ToInt32(number) > num)
												{
													num = Convert.ToInt32(number);
												}
												goto IL_175;
											}
											catch (Exception)
											{
												goto IL_175;
											}
										}
										num++;
										parameter3.Set(num.ToString());
									}
									IL_175:
									if (parameter2 != null)
									{
										parameter2.Set(num.ToString());
									}
								}
								Parameter parameter4 = pipe.GetParameter("区号楼号");
								if (parameter4 != null)
								{
									parameter4.Set(areaAndFloor);
									break;
								}
								break;
							}
						}
						result = true;
					}
				}
			}
			catch (Exception ex)
			{
				ex.ToString();
				throw ex;
			}
			return result;
		}

		public static readonly Guid RiserPipeMarkGUID = new Guid("{1E1D457E-15B3-4702-9800-6AE94F2A5CF1}");

		public static readonly Guid GroupGUID = new Guid("A44A83A74FFF4087BF44F8842D7982A4");

		public static readonly double TextHeight = 500.0;

		public static readonly double TextLength = 1200.0;

		public static double XOffsetHori = 460.0;

		public static double XOffsetVert = 200.0;

		public static double YOffSetVert = 550.0;
	}
}
